.TH std::filesystem::copy_options 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::filesystem::copy_options \- std::filesystem::copy_options

.SH Synopsis
   Defined in header <filesystem>
   enum class copy_options {

       none = /* unspecified */,
       skip_existing = /* unspecified */,
       overwrite_existing = /* unspecified */,
       update_existing = /* unspecified */,
       recursive = /* unspecified */,           \fI(since C++17)\fP
       copy_symlinks = /* unspecified */,
       skip_symlinks = /* unspecified */,
       directories_only = /* unspecified */,
       create_symlinks = /* unspecified */,
       create_hard_links = /* unspecified */

   };

   This type represents available options that control the behavior of the copy() and
   copy_file() function.

   copy_options satisfies the requirements of BitmaskType (which means the bitwise
   operators operator&, operator|, operator^, operator~, operator&=, operator|=, and
   operator^= are defined for this type). none represents the empty bitmask; every
   other enumerator represents a distinct bitmask element.

.SH Member constants

   At most one copy option in each of the following options groups may be present,
   otherwise the behavior of the copy functions is undefined.

    Member constant                                Meaning
               options controlling copy_file() when the file already exists
   none               Report an error (default behavior).
   skip_existing      Keep the existing file, without reporting an error.
   overwrite_existing Replace the existing file.
   update_existing    Replace the existing file only if it is older than the file being
                      copied.
               options controlling the effects of copy() on subdirectories
   none               Skip subdirectories (default behavior).
   recursive          Recursively copy subdirectories and their content.
               options controlling the effects of copy() on symbolic links
   none               Follow symlinks (default behavior).
   copy_symlinks      Copy symlinks as symlinks, not as the files they point to.
   skip_symlinks      Ignore symlinks.
                   options controlling the kind of copying copy() does
   none               Copy file content (default behavior).
   directories_only   Copy the directory structure, but do not copy any non-directory
                      files.
                      Instead of creating copies of files, create symlinks pointing to
   create_symlinks    the originals. Note: the source path must be an absolute path
                      unless the destination path is in the current directory.
   create_hard_links  Instead of creating copies of files, create hardlinks that
                      resolve to the same files as the originals.

.SH Example


// Run this code

 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 namespace fs = std::filesystem;

 int main()
 {
     fs::create_directories("sandbox/dir/subdir");
     std::ofstream("sandbox/file1.txt").put('a');
     fs::copy("sandbox/file1.txt", "sandbox/file2.txt"); // copy file
     fs::copy("sandbox/dir", "sandbox/dir2"); // copy directory (non-recursive)
     const auto copyOptions = fs::copy_options::update_existing
                            | fs::copy_options::recursive
                            | fs::copy_options::directories_only
                            ;
     fs::copy("sandbox", "sandbox_copy", copyOptions);
     static_cast<void>(std::system("tree"));
     fs::remove_all("sandbox");
     fs::remove_all("sandbox_copy");
 }

.SH Possible output:

 .
 ├── sandbox
 │   ├── dir
 │   │   └── subdir
 │   ├── dir2
 │   ├── file1.txt
 │   └── file2.txt
 └── sandbox_copy
     ├── dir
     │   └── subdir
     └── dir2

 8 directories, 2 files

.SH See also

   copy      copies files or directories
   \fI(C++17)\fP   \fI(function)\fP
   copy_file copies file contents
   \fI(C++17)\fP   \fI(function)\fP
